// 认证相关API
import { AxiosManager, handleApiError, baseAPI, isResponseSuccess } from '../utils/axiosInstance';
import type { ApiResponse } from '../utils/axiosInstance';

// 认证相关类型定义
export interface LoginCredentials {
  username: string;
  password: string;
}

export interface UserInfo {
  id: string;
  username: string;
  role?: string;
  permissions?: string[];
}

export interface LoginResponse {
  token: string;
  user: UserInfo;
}

// 添加注册相关的类型定义
export interface RegisterCredentials {
  username: string;
  password: string;
  email: string;
}

export interface RegisterResponse {
  success: boolean;
  message: string;
}

/**
 * 认证API服务
 */
export class AuthService {
  /**
   * 用户注册
   * @param credentials 注册信息
   * @returns Promise<ApiResponse<RegisterResponse>> 注册响应
   */
  public static async register(credentials: RegisterCredentials): Promise<ApiResponse<RegisterResponse>> {
    try {
      console.log('准备发送注册请求:', credentials);
      
      // 调用后端注册API
      const response = await baseAPI.post<ApiResponse<RegisterResponse>>('/auth/register', credentials);
      
      console.log('注册API响应:', response);
      
      // 检查响应是否成功
      if (!isResponseSuccess(response.data)) {
        throw new Error(response.data.msg || '注册失败');
      }
      
      return response.data;
    } catch (error) {
      console.error('注册错误:', error);
      return handleApiError(error, '注册失败');
    }
  }

  /**
   * 用户登录
   * @param credentials 登录凭证
   * @returns Promise<ApiResponse<LoginResponse>> 登录响应
   */
  public static async login(credentials: LoginCredentials): Promise<ApiResponse<LoginResponse>> {  
    try {  
      // 直接调用真实后端API  
      const response = await baseAPI.post<ApiResponse<{token: string; username: string}>>('/auth/login', credentials);  
      
      console.log('登录API完整响应:', response);  
      console.log('登录API响应数据:', response.data);  
      console.log('登录API响应code:', response.data.code);  
      
      // 检查响应是否成功  
      if (!isResponseSuccess(response.data)) {  
        throw new Error(response.data.msg || '登录失败');  
      }  
      
      // 确保有data对象和token  
      if (!response.data.data || !response.data.data.token) {  
        throw new Error('登录失败，未获取到令牌信息');  
      }  
      
      // 使用正确的类型断言来访问后端返回的字段
      const data = response.data.data as {token: string; username: string};
      const { token, username } = data;  
      
      // 保存认证信息  
      console.log('登录成功，保存令牌');  
      AxiosManager.saveAuthToken(token);  
      
      // 保存用户信息 - 根据后端返回的数据创建符合UserInfo接口的对象  
      if (username) {  
        const userInfo: UserInfo = {
          id: username, // 由于后端没有返回id，暂时用username作为id
          username: username
        };
        console.log('保存用户信息:', userInfo);  
        AxiosManager.saveUserInfo(userInfo);  
      }  
      
      // 创建符合LoginResponse接口的返回对象
      const loginResponse: LoginResponse = {
        token: token,
        user: {
          id: username || '',
          username: username || ''
        }
      };
      
      // 返回处理后的响应
      return {
        code: response.data.code,
        msg: response.data.msg,
        data: loginResponse
      };
    } catch (error) {  
      console.error('登录错误:', error);  
      return handleApiError(error, '登录失败');  
    }  
  }

  /**
   * 用户登出
   * @returns Promise<ApiResponse<null>> 登出响应
   */
  public static async logout(): Promise<ApiResponse<null>> {
    try {
      const response = await baseAPI.post<ApiResponse<null>>('/auth/logout');
      
      // 清除认证信息
      AxiosManager.clearAuthData();
      
      return response.data;
    } catch (error) {
      // 失败也清除认证信息以确保安全
      AxiosManager.clearAuthData();
      return handleApiError(error, '登出失败');
    }
  }

  /**
   * 获取当前用户信息
   * @returns Promise<ApiResponse<UserInfo>> 用户信息响应
   */
  public static async getCurrentUser(): Promise<ApiResponse<UserInfo>> {
    try {
      // 首先尝试从服务器获取最新用户信息
      const response = await baseAPI.get<ApiResponse<UserInfo>>('/auth/me');
      
      // 检查响应是否成功且包含用户信息
      if (isResponseSuccess(response.data) && response.data.data) {
        console.log('获取用户信息成功，缓存到本地');
        AxiosManager.saveUserInfo(response.data.data);
        return response.data;
      }
      
      // 如果服务器返回失败，尝试使用本地缓存
      const cachedUser = AxiosManager.getUserInfo<UserInfo>();
      if (cachedUser) {
        console.log('使用本地缓存的用户信息');
        return {
          code: '200',
          msg: '成功',
          data: cachedUser,
        };
      }
      
      // 服务器失败且无缓存时返回错误
      throw new Error('获取用户信息失败且无本地缓存');
    } catch (error) {
      console.error('获取用户信息错误:', error);
      return handleApiError(error, '获取用户信息失败');
    }
  }
}

// 导出认证工具函数
// 注意：这里直接使用AxiosManager的方法，避免重复实现
// 如果需要自定义逻辑，可以在这里添加

export const authUtils = {
  isAuthenticated: AxiosManager.isAuthenticated,
  getCurrentUser: AxiosManager.getUserInfo<UserInfo>,
  clearAuthData: AxiosManager.clearAuthData,
};